When writing software applications in a high-level programming language, software engineers often face design problems that can differ in details of their implementations but still lend themselves to the same general solution. A design pattern can provide a general solution that a software engineer can apply to a specific problem at hand to produce a solution. Many design patterns can serve as descriptions or templates that can teach a general approach for how to solve a software design problem.
Design patterns are commonly used in object-oriented software engineering and design. Object-oriented design patterns typically depict high-level relationships or interactions between or among classes or objects. A software engineer can use such a depiction to create classes and objects that adhere to the pattern and write source code that implements desired functionality. High quality source code that implements a basic pattern can be reused in other projects that have similar design problems.
Object-oriented design and programming concepts have proven to be powerful tools for software development. However, use of object-oriented code is not an ideal implementation in every programming context. One of these contexts is the field of relational databases. Relational databases can store and manipulate vast amounts of data very quickly. Among the reasons for these capabilities is the fact that much of the available relational database code and methods has been refined and optimized over a period spanning several decades to remove processing bottlenecks.
Object-oriented applications have a relatively large amount of processing overhead associated with tasks such as object creation. This processing overhead can significantly and negatively impact performance of applications that work with relational databases and performance of the relational databases themselves. A major contributing cause of this overhead is object creation from data retrieved from the relational database. Current object-oriented systems lack the ability to efficiently interact with data sources without incurring large amounts of processing overhead.